The present invention relates generally to computer animation, and specifically to interactive rendering of computer graphic objects from a remote source.
In recent years, the use of the World Wide Web (WWW) has been rapidly growing. In use of the WWW, a client computer user connects to a Web site on a server and requests that the server download and display Web pages on the client computer. In response to the request, the server sends to the client computer graphic files, which include media elements (pictures, animations, texts, sound), scripts of instructions to be performed by an Internet browser program running on the computer, and in some cases executable software code, e.g., Java code. In addition, the server usually sends a file in HTML format which describes the layout of the computer graphic files on the screen. Generally, the Internet browser program operates independently of other programs on the client computer and, in particular, limits the access of scripts from the server to files stored in the memory of the client computer, and especially to graphic objects stored in the memory.
In order to attract users, sites must be interesting, and it is typically desired that sites display graphics and animation. However, the time required to download and display Web pages which include animation, including three-dimensional (3D) animation, on the client computer is relatively large, which is inconvenient to users and may discourage them from using such sites. Frequently it is desired to render animated advertisements along with user-chosen data from a Web site. Such advertisements must not require long transmission periods, or the visitor at the site may leave the site and be discouraged from returning.
Various compression methods have been suggested to reduce the data volume of a transmitted Web page and thus reduce the amount of time required to display the page on the computer. However, even using such compression methods, available network transmission bandwidth is typically still much lower than required to transmit large high quality animation streams. The users therefore must either settle for reduced quality of the animation stream or limit its size and/or length. In addition, some compression methods require lengthy decompression, which wastes much of the time saved by the compression.
Another method, referred to as caching or data pushing, described, for example, in U.S. Pat. No. 5,727,129, which is incorporated herein by reference, includes xe2x80x9cpushingxe2x80x9d data in advance while the connection of the client computer to the network is idle. The computer, or the server, chooses data which may be of interest to the user and sends this data to the computer in advance of a specific request from the user, while the connection is idle. However, in many cases, there is no way to predict what the user will want to see. The number of Web pages which may be stored on the computer is limited, and the user may want updated versions of the page. Furthermore, there is not always an idle line available for significant periods of time.
Some Web browsers allow server-originated code to access the hard disk of the computer running the browser. Such access is normally performed using programs known as xe2x80x9cplug-insxe2x80x9d or ActiveX controls. In most cases, when such access is attempted, the user of the computer is typically warned of a potential security violation, arising from such access.
It is an object of the present invention to provide improved methods and apparatus for fast rendering of an animation object, preferably a three-dimensional (3D) object, on a remote computer graphic display.
In preferred embodiments of the present invention, an animation image of an object comprises a set of sub-objects (also referred to herein as elements) which are arranged in a predetermined hierarchy and animated responsive to the hierarchy. A structure record (also referred to as a xe2x80x9cskeletonxe2x80x9d) describes relationships between the sub-objects in the hierarchy. Preferably, the structure record is written in accordance with a common script language, such as JavaScript. A plurality of sub-object records describe the sub-objects. At least some of the sub-object records are stored in a local memory associated with a client computer.
When the animation image is to be rendered on a display associated with the client computer, a server sends the structure record describing the animation image to the client computer, together with required sub-object records, if any, which are not stored in the client computer""s local memory. Typically, only the structure record and a minimal number of sub-object records need be sent from the server. Thus, in most cases remote rendering of animation objects requires relatively low bandwidth, since the heavy graphical parts of the objects are stored permanently in the memory associated with the client computer.
In the context of the present patent application, the term xe2x80x9cobjectxe2x80x9d is used to refer to a modular, graphic and/or mathematical description of an image (generally a representation of a physical object, which may be naturalistic or fanciful). The skeleton of the object preferably defines the parts of the object and the joints connecting those parts. The hierarchical structure of objects allows a user to exchange sub-objects between objects that share a common hierarchy.
In some preferred embodiments of the present invention, the object represents a human, humanoid or animal character, and the sub-objects describe organs (such as limbs) and sub-organs (such as parts of the limbs) of the character. Other optional sub-objects describe attributes such as sound and rules governing behavior of the object, such as motions of the image.
Preferably, the objects also include sub-objects that define their response to sensitivity conditions that may arise externally to the object itself, such as the presence of other objects in the computer display. Furthermore, objects may include sub-objects that have learning capabilities, as are known in the art, whereby the behavior of the object is modified adaptively in response to inputs from the computer-animated environment. Preferably, some of the sub-objects are themselves formed of other sub-objects. In a preferred embodiment of the present invention, the objects comprise Smart Objects as are described in PCT publication WO97/35280, which is incorporated herein by reference.
Preferably, the client computer runs a scene manager program, which displays the animated images on a screen associated with the client computer. The scene manager is preferably part of a Web browser, which downloads graphic pages from a network. The client computer preferably also runs an element manager program, which keeps track of the locations of the records of sub-objects stored on the client computer. The scene manager interacts with the element manager to properly render the object using the received records and the stored records.
Preferably, the element manager maintains a look-up table which is used to find the location in the memory of sub-objects referenced by the received structure record. Most preferably, the element manager receives the name of a desired sub-object and returns a pointer to the stored location of the object based on the name. If the desired sub-object in not held in the memory of the client computer, the element manager returns a negative answer. Alternatively or additionally, the element manager orders the requested element from the server and provides the scene manager with a pointer to an input directory in which received sub-objects are stored.
In some preferred embodiments of the present invention, the element manager is included within the Web browser. Thus, the user does not need to install any xe2x80x9cplug-inxe2x80x9d to the browser. Preferably, the browser as supplied to the client computer includes a set of records describing commonly-used sub-objects. Most preferably, the browser and set of records are pre-installed in a computer with dedicated three-dimensional graphics capabilities.
In some preferred embodiments of the present invention, when a sub-object not already in the memory is received by the client computer, the sub-object is stored in the memory and its address is added to the look up table.
In some preferred embodiments of the present invention, when a server instructs the client computer to render a new object, the server sends the computer a list of the sub-objects to be used in constructing the transmitted object, and the computer responds with a list of the sub-objects which the computer has and/or with a list of the sub-objects which the computer does not have. The server responds by sending the sub-objects missing from the client computer. Preferably, while waiting for the computer""s response, the server sends the structure record and/or records describing sub-objects which are least likely to be already stored in the memory of the computer.
Preferably, when a computer responds that it does not have a copy of a sub-object which itself is formed of sub-sub-objects, the server sends a second list which lists the sub-sub-objects which form the sub-object and requests that the computer identify those sub-sub-objects which it does not have. This process may continue for the sub-sub-objects until there are no further sub-objects or until the records describing the sub-objects are so small that it is simpler to send the records, rather than to ask if they are needed. Alternatively or additionally, the server only asks the client computer about sub-objects for which there is a high probability that the computer has records describing its sub-sub-objects.
Alternatively or additionally, the client computer determines the required sub-objects from the received structure record. Preferably, the JavaScript of the structure record describes the animation conditionally, based upon the presence or lack of sub-objects in the client computer. The JavaScript preferably uses xe2x80x9cIf-Thenxe2x80x9d directives to reference the sub-objects, wherein a referenced sub-object is first accessed in the local memory using the element manager, and if it is not found in the local memory, the sub-object is requested from the server either by the scene manger or by the element manager.
There is therefore provided in accordance with a preferred embodiment of the present invention, a method for rendering an animation object, including a plurality of sub-objects, on a display of a client computer under control of a remote server, the method includes transferring from the server to the client, program code which describes a structure of the object, accessing within a local memory associated with the client a program description of at least one of the sub-objects of the object, and displaying the object such that the sub-object is coupled to the structure in accordance with the program code.
Preferably, the method includes reporting to the server the identity of at least some of the sub-objects stored in the memory.
Preferably, reporting the identity of the sub-objects includes receiving a list of sub-objects from the server and reporting on a correspondence between the list and the sub-objects that are stored in the memory.
Preferably, the method includes transferring from the server to the client descriptions of sub-objects not already stored in the memory and storing the transferred descriptions in the memory.
Preferably, at least some of the sub-objects include sub-sub-objects, and transferring descriptions of the sub-objects includes transferring only those sub-sub-objects not stored in the memory.
Preferably, the method includes storing in the memory a plurality of descriptions of sub-objects when installing a browser on the computer.
Preferably, accessing the at least one description includes looking up the location of the description in the memory in a look-up table.
Preferably, accessing the at least one description includes receiving an exact location of the description from an element manager and accessing the exact location.
Preferably, the object includes a three dimensional graphical object.
Preferably, at least some of the sub-objects include graphical descriptions of parts of the object.
Preferably, at least some of the sub-objects include sound modules.
Preferably, accessing the program description of at least one of the sub-objects includes calling a routine which returns the address of the object in the local memory.
Preferably, transferring the program code includes transferring a script which references the sub-objects in the local memory and if the object is not found in the local memory, references the sub-object in an input location.
There is Further provided in accordance with a preferred embodiment of the present invention, apparatus for rendering an image of an animation object under control of a remote server, the apparatus includes a memory, which stores descriptions of sub-objects which are used to form the objects, an animation generator, linked locally to the memory, which receives a skeleton which describes a structure of the object and retrieves the descriptions of at least some of those sub-objects from the memory, and a display on which the image is displayed by rendering the sub-objects responsive to the descriptions thereof and responsive to the skeleton.
Preferably, the object includes a three dimensional object.
Preferably, the memory includes a look up table which lists the sub-objects of which there are descriptions in the memory.
Preferably, the animation generator receives from the server a list of the sub-objects in the object and responds by indicating to the server those sub-objects of which descriptions are not stored in the memory.
The present invention will be more fully understood from the following detailed description of the preferred embodiments thereof, taken together with the drawings in which: